Computer users have become accustomed to the use of drop-down menus as a means for issuing commands to a computer. This method of issuing commands became commonplace with the advent of the graphical user interface (GUI), in which most commands could be displayed on a video monitor and selected using a mouse. The predecessor to the GUI was the command-line interface, in which the user issued a command to the computer by typing the command on a command-line and submitting the complete command to the computer (usually by pressing the ENTER key). GUIs were developed to make using a computer easier for less-technical users, by simplifying the process of generating and submitting commands to the computer.
One innovation of the GUI was to place most of an application program's available functions within the view of the user. Typically, symbols representing the commands are displayed on the computer's monitor in the form of text, buttons, or icons. By the use of a mouse or other pointing device, the computer user merely points to the command symbols for a desired command and selects the command. In response to this selection, the computer executes the function or operation associated with the command. Thus, the user need not memorize commands or refer to an operation manual in order to execute desired operations.
Menus provide a means of organizing command symbols such that large numbers of commands can be displayed on demand. By grouping commands within a menu, any number of commands can be displayed when the user selects a menu from a list of available menus. The list of available menus can be altered to accommodate the commands that are available in a given context. For example, where the user is using a spreadsheet application program, the list of menus may include only those menus pertaining to the "active" spreadsheet application program and may not include menus that contain commands pertaining to an "inactive" word processing application program. Similarly, where the user is utilizing the calculation capabilities of the spreadsheet application program, a different set of menus can be made available than when the user is utilizing the graphing capabilities of the same spreadsheet application program.
Most GUIs provide the list of available menus in the form of a Menu Bar across the top of the viewable area of the computer's monitor and/or across the top of the viewable area of a particular application frame. Although the contents of the Menu Bar (menu titles) may change in response to a change in available menus, the Menu Bar is typically always visible when the GUI is operative. To view the contents of a particular menu, the user selects the menu title from the Menu Bar, and the menu associated with the menu title is displayed. Because the menu typically descends from the Menu Bar, such menus are commonly called "drop-down" menus. A menu's contents are referred to as menu items. Menu items include the command symbols as well as other elements such as dividing lines for partitioning the command symbols into sets. The desired command is executed when the user selects the corresponding command symbol (i.e., menu item) from the menu.
A menu structure consists of a Menu Bar, at least one menu title, and any number of menu items. The menu structure can be defined in one or more menu data files that contain information pertaining to the menu titles in the Menu Bar, the menu items in the menu, and the characteristics of each menu item. By calling certain routines, an application program can direct the computer's operating system to build the menu structure according to the specifications stored in the menu data files. Building menus is the process of assembling the constituent parts and making the menu available for access by the user.
Most application programs perform menu building in the background. That is, the menu building process is hidden from the user. After building the menus required by a particular application program, the complete structure of the menus can be placed in the computer's random access memory (RAM) and accessed instantly, so that the menus are available to the user on demand. The user sees only the completed menu when the user selects a menu title from the Menu Bar. Depending on when the menu is built, the user may perceive a delay between the time that the user selects a menu and the time that the menu is displayed. Most application programs build menus upon startup (boot) or upon user demand.
The advantage of building an application program's menus at boot is that the menu structure will have been completely built when the user demands the menu. The user of an application program that builds menus at boot will not normally be able to perceive a delay between when the user selects the menu title and when the menu is displayed. This is because the menu will have been built in advance and will have been stored in RAM for essentially immediate display. Unfortunately, this method increases the boot time for the application program, because the application program is not usable by the user until the entire menu structure has been built and stored in RAM. Where the required boot time must be minimized, this method is not appropriate. Moreover, this method is inefficient in that every menu is built at boot and the user must wait for the building of a menu that may never be used.
Another commonly used method of menu building is to build menus on demand. That is, a menu is built and stored in RAM, only after the user selects the menu title for the first time following boot. One advantage to this method is that an unused menu is never built, and the application program is, therefore, more efficient than an application program that builds all of the menus. Unfortunately, this method will usually expose the user to a perceivable delay on the first time that each different menu is selected (a "first-time" delay). Because a menu that is selected by the user for the first time must be built at that time, the user must wait for the application program to build, store, and display the menu.
Therefore, there is a need in the art for an improved method of building menus such that an application program may build its entire menu structure without lengthening the application program's boot time. This method should build menus so that there are no first-time delays or so that first-time delays are minimized.